///回顾：
//继承
//多态：多态是一种思想。依靠动态绑定实现。
//父类引用指向子类不同的对象，调用重写方法会发生不同的行为
//多态的条件 向上转型 重写 父类引用调用父类子类重写的方法
//图形的例子
//重写：
//向上转型
//向下转型

//抽象类：如果一个类不能准确表现对象，则可以定义为抽象类  比如动物，蔬菜，植物1
//抽象类的最大意义就是为了被继承
//需要通过abstract修饰类,抽象类不能被实例化
//抽象类可以有普通方法，也可以有抽象方法，子类必须重写父类的抽象方法
//如果不重写，则子类也需要是抽象类
//抽象类不一定有抽象方法，有抽象方法一定有抽象类1

//抽象类是对一个事物在抽象
//接口是对一个行为或者规范在设定标准
public class Test {
//    Dog dog1 = new Dog("小七",10);
//    Dog dog2 = new Dog("小太阳",11);

    public static void drawMap(Shape shape) {
        shape.draw();
    }

    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        Rect rect = new Rect();
        Flower flower =new Flower();
        Shape[] shapes = {cycle,flower};
        for (Shape shape:
             shapes) {
            shape.draw();
        }
        System.out.println("===========");
        drawMap(cycle);
        drawMap(flower);
        drawMap(rect);
    }
}

abstract class Shape {

    public abstract void draw();

}
class Rect extends Shape {

    @Override
    public void draw() {
        System.out.println("👩🏾‍🤝‍👩🏽");
    }
}

class Cycle extends Shape {

    @Override
    public void draw() {
        System.out.println("⚪");
    }
}

class Flower extends Shape {

    @Override
    public void draw() {
        System.out.println("❀");
    }
}

abstract class Animal {
    public String name;
    public int age;

    public abstract void eat();
    public Animal(String name ,int age) {
        this.name = name;
        this.age = age;
    }
    public Animal() {

    }
}

class Dog extends Animal {
    public Dog(String name,int age) {
        super(name,age);
    }

    public Dog() {
        super("小太阳",10);
    }
    @Override
    public void eat() {
        System.out.println(name + "吃狗粮");
    }
}


//abstract class Shape {
////    public String name;
////    public int age;
//    public void draw() {
//        System.out.println("draw shape");
//    }
//
//
//}
//
//class Rect extends Shape {
//
//    public void eat() {
//
//    }

